{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Needle-in-Haystack Benchmark Notebook\n",
    "\n",
    "This notebook measures the performance of a “needle in a haystack” lookup query—finding one specific row among many—for three storage backends: SQLite, MongoDB, and ParquetDB.\n",
    "\n",
    "---\n",
    "\n",
    "## Benchmark Details\n",
    "\n",
    "- **Data Generation:**  \n",
    "  - Each run generates *N* rows × 100 columns of integers, with exactly one row set to `–1` (“the needle”) and all other entries random in [0, 1 000 000].  \n",
    "  - Row counts tested: `1, 10, 100, 1 000, 10 000, 100 000, 1 000 000`.  \n",
    "  - Integers chosen as a basic primitive type—byte size is the main factor, so these results represent a **lower bound** on query time. More complex or larger types will incur higher cost.\n",
    "\n",
    "- **Parquet Normalization Settings (defaults):**  \n",
    "  - **Row‐group size:** 50 000–100 000 rows per group  \n",
    "  - **Max rows per file:** 10 000 000  \n",
    "  - Tuning these can shift performance between inserts, reads, and updates.\n",
    "\n",
    "---\n",
    "\n",
    "## System Specifications\n",
    "\n",
    "- **Operating System:** Windows 10  \n",
    "- **Processor:** AMD Ryzen 7 3700X 8‑Core @ 3.6 MHz (8 cores, 16 logical processors)  \n",
    "- **Memory:** 128 GB DDR4‑3600 MHz (4×32 GB DIMMs) \n",
    "- **Storage**: SATA HDD 2TB (Model: ST2000DM008-2FR102)\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install parquetdb\n",
    "!pip install pymongo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import time\n",
    "import random\n",
    "import shutil\n",
    "import sqlite3\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.ticker as ticker\n",
    "from mpl_toolkits.axes_grid1.inset_locator import inset_axes\n",
    "from pymongo import MongoClient\n",
    "import pyarrow.compute as pc\n",
    "\n",
    "from parquetdb import ParquetDB, config\n",
    "\n",
    "\n",
    "bench_dir = os.path.join(config.data_dir, \"benchmarks\")\n",
    "sqlite_dir = os.path.join(bench_dir, \"sqlite\")\n",
    "mongo_dir  = os.path.join(bench_dir, \"mongodb\")\n",
    "pq_dir     = os.path.join(bench_dir, \"parquetdb\")\n",
    "for d in (sqlite_dir, mongo_dir, pq_dir):\n",
    "    os.makedirs(d, exist_ok=True)\n",
    "\n",
    "row_counts = [1, 10, 100, 1_000, 10_000, 100_000, 1_000_000]\n",
    "n_cols = 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. SQLite Becnhmark"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1 Helper functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_data_sqlite(n_rows, n_cols=100, needle=-1):\n",
    "    idx = random.randrange(n_rows)\n",
    "    data = []\n",
    "    for i in range(n_rows):\n",
    "        vals = [needle]*n_cols if i == idx else [random.randint(0,1_000_000) for _ in range(n_cols)]\n",
    "        data.append(tuple(vals))\n",
    "    return data\n",
    "\n",
    "def run_sqlite(n_rows, use_index):\n",
    "    db_file = os.path.join(sqlite_dir, f\"bench_{n_rows}_{'idx' if use_index else 'noidx'}.db\")\n",
    "    if os.path.exists(db_file): os.remove(db_file)\n",
    "\n",
    "    # Insert\n",
    "    start = time.time()\n",
    "    conn = sqlite3.connect(db_file)\n",
    "    cols = \", \".join(f\"col{i} INTEGER\" for i in range(n_cols))\n",
    "    conn.execute(f\"CREATE TABLE t ({cols})\")\n",
    "    conn.execute(\"PRAGMA synchronous = OFF\")\n",
    "    conn.execute(\"PRAGMA journal_mode = MEMORY\")\n",
    "    placeholders = \", \".join(\"?\" for _ in range(n_cols))\n",
    "    conn.executemany(f\"INSERT INTO t VALUES ({placeholders})\", generate_data_sqlite(n_rows, n_cols))\n",
    "    conn.commit()\n",
    "    conn.close()\n",
    "    insert_time = time.time() - start\n",
    "\n",
    "    # Optional index\n",
    "    if use_index:\n",
    "        conn = sqlite3.connect(db_file)\n",
    "        conn.execute(\"CREATE INDEX idx_col0 ON t(col0)\")\n",
    "        conn.commit()\n",
    "        conn.close()\n",
    "\n",
    "    # Query\n",
    "    start = time.time()\n",
    "    conn = sqlite3.connect(db_file)\n",
    "    cur = conn.cursor()\n",
    "    cur.execute(\"SELECT col0 FROM t WHERE col0 = -1\")\n",
    "    assert cur.fetchone()[0] == -1\n",
    "    conn.close()\n",
    "    read_time = time.time() - start\n",
    "\n",
    "    return insert_time, read_time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2 Run without Index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "results_sqlite = {\"n_rows\": [], \"insert_noidx\": [], \"read_noidx\": []}\n",
    "for n in row_counts:\n",
    "    it, rt = run_sqlite(n, use_index=False)\n",
    "    results_sqlite[\"n_rows\"].append(n)\n",
    "    results_sqlite[\"insert_noidx\"].append(it)\n",
    "    results_sqlite[\"read_noidx\"].append(rt)\n",
    "df_sqlite_noidx = pd.DataFrame(results_sqlite)\n",
    "df_sqlite_noidx.to_csv(os.path.join(sqlite_dir, \"sqlite_noidx.csv\"), index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3 Run with Index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "results_sqlite_idx = {\"n_rows\": [], \"insert_idx\": [], \"read_idx\": []}\n",
    "for n in row_counts:\n",
    "    it, rt = run_sqlite(n, use_index=True)\n",
    "    results_sqlite_idx[\"n_rows\"].append(n)\n",
    "    results_sqlite_idx[\"insert_idx\"].append(it)\n",
    "    results_sqlite_idx[\"read_idx\"].append(rt)\n",
    "df_sqlite_idx = pd.DataFrame(results_sqlite_idx)\n",
    "df_sqlite_idx.to_csv(os.path.join(sqlite_dir, \"sqlite_idx.csv\"), index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. MongoDB Benchmark"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1 Helper functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_data_mongo(n_rows, n_cols=100, needle=-1):\n",
    "    idx = random.randrange(n_rows)\n",
    "    docs = []\n",
    "    for i in range(n_rows):\n",
    "        base = {f\"col_{j}\": needle for j in range(n_cols)} if i == idx else \\\n",
    "               {f\"col_{j}\": random.randint(0,1_000_000) for j in range(n_cols)}\n",
    "        docs.append(base)\n",
    "    return docs\n",
    "\n",
    "def run_mongo(n_rows, use_index):\n",
    "    client = MongoClient(\"mongodb://localhost:27017/\")\n",
    "    db = client.benchmark\n",
    "    coll = db.t\n",
    "    client.drop_database(\"benchmark\")\n",
    "\n",
    "    # Insert\n",
    "    start = time.time()\n",
    "    coll.insert_many(generate_data_mongo(n_rows, n_cols))\n",
    "    insert_time = time.time() - start\n",
    "\n",
    "    # Index?\n",
    "    if use_index:\n",
    "        coll.create_index(\"col_0\")\n",
    "\n",
    "    # Query\n",
    "    start = time.time()\n",
    "    res = list(coll.find({\"col_0\": -1}, {\"col_0\":1, \"_id\":0}))\n",
    "    assert res[0][\"col_0\"] == -1\n",
    "    read_time = time.time() - start\n",
    "    client.close()\n",
    "\n",
    "    return insert_time, read_time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2 Run without Index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "results_mongo_noidx = {\"n_rows\": [], \"insert_noidx\": [], \"read_noidx\": []}\n",
    "for n in row_counts:\n",
    "    it, rt = run_mongo(n, use_index=False)\n",
    "    results_mongo_noidx[\"n_rows\"].append(n)\n",
    "    results_mongo_noidx[\"insert_noidx\"].append(it)\n",
    "    results_mongo_noidx[\"read_noidx\"].append(rt)\n",
    "df_mongo_noidx = pd.DataFrame(results_mongo_noidx)\n",
    "df_mongo_noidx.to_csv(os.path.join(mongo_dir, \"mongo_noidx.csv\"), index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>n_rows</th>\n",
       "      <th>insert_noidx</th>\n",
       "      <th>read_noidx</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>0.018000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>10</td>\n",
       "      <td>0.012573</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>100</td>\n",
       "      <td>0.023000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1000</td>\n",
       "      <td>0.139594</td>\n",
       "      <td>0.002002</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>10000</td>\n",
       "      <td>1.114362</td>\n",
       "      <td>0.007001</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   n_rows  insert_noidx  read_noidx\n",
       "0       1      0.018000    0.000000\n",
       "1      10      0.012573    0.000000\n",
       "2     100      0.023000    0.000000\n",
       "3    1000      0.139594    0.002002\n",
       "4   10000      1.114362    0.007001"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_mongo_noidx.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3 Run with Index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "results_mongo_idx = {\"n_rows\": [], \"insert_idx\": [], \"read_idx\": []}\n",
    "for n in row_counts:\n",
    "    it, rt = run_mongo(n, use_index=True)\n",
    "    results_mongo_idx[\"n_rows\"].append(n)\n",
    "    results_mongo_idx[\"insert_idx\"].append(it)\n",
    "    results_mongo_idx[\"read_idx\"].append(rt)\n",
    "df_mongo_idx = pd.DataFrame(results_mongo_idx)\n",
    "df_mongo_idx.to_csv(os.path.join(mongo_dir, \"mongo_idx.csv\"), index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. ParquetDB Benchmark"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1 Helper functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_data_pq(n_rows, n_cols=100, needle=-1):\n",
    "    # one dict per row\n",
    "    idx = random.randrange(n_rows)\n",
    "    data = []\n",
    "    for i in range(n_rows):\n",
    "        row = {f\"col_{j}\": (needle if i == idx else random.randint(0,1_000_000))\n",
    "               for j in range(n_cols)}\n",
    "        data.append(row)\n",
    "    return data\n",
    "\n",
    "def run_parquetdb(n_rows):\n",
    "    db_path = os.path.join(pq_dir, f\"bench_{n_rows}\")\n",
    "    if os.path.exists(db_path): shutil.rmtree(db_path)\n",
    "    db = ParquetDB(db_path=db_path)\n",
    "    start = time.time()\n",
    "    db.create(generate_data_pq(n_rows, n_cols))\n",
    "    insert_time = time.time() - start\n",
    "\n",
    "    start = time.time()\n",
    "    tbl = db.read(columns=[\"col_0\"], filters=[pc.field(\"col_0\")==-1]).combine_chunks()\n",
    "    assert tbl[\"col_0\"].to_pylist()[0] == -1\n",
    "    read_time = time.time() - start\n",
    "\n",
    "    return insert_time, read_time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2 Run ParquetDB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] 2025-04-19 12:26:47 - parquetdb.core.parquetdb[205][__init__] - Initializing ParquetDB with db_path: Z:\\data\\parquetdb\\data\\benchmarks\\parquetdb\\bench_1\n",
      "[INFO] 2025-04-19 12:26:47 - parquetdb.core.parquetdb[207][__init__] - verbose: 1\n"
     ]
    }
   ],
   "source": [
    "results_pq = {\"n_rows\": [], \"insert\": [], \"read\": []}\n",
    "for n in row_counts:\n",
    "    it, rt = run_parquetdb(n)\n",
    "    results_pq[\"n_rows\"].append(n)\n",
    "    results_pq[\"insert\"].append(it)\n",
    "    results_pq[\"read\"].append(rt)\n",
    "df_pq = pd.DataFrame(results_pq)\n",
    "df_pq.to_csv(os.path.join(pq_dir, \"parquetdb_needle_bench.csv\"), index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Load & Preview All Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_sql_no = pd.read_csv(os.path.join(sqlite_dir, \"sqlite_noidx.csv\"))\n",
    "df_sql_ix = pd.read_csv(os.path.join(sqlite_dir, \"sqlite_idx.csv\"))\n",
    "df_mg_no = pd.read_csv(os.path.join(mongo_dir, \"mongo_noidx.csv\"))\n",
    "df_mg_ix = pd.read_csv(os.path.join(mongo_dir, \"mongo_idx.csv\"))\n",
    "df_pq    = pd.read_csv(os.path.join(pq_dir, \"parquetdb_needle_bench.csv\"))\n",
    "\n",
    "# Combine for plotting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Plot Read Times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "tags": [
     "nbsphinx-thumbnail"
    ]
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\lllang\\AppData\\Local\\Temp\\ipykernel_49100\\3178427722.py:45: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n",
      "  plt.tight_layout()\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.rcParams.update({\n",
    "    \"axes.labelsize\": 18, \"axes.titlesize\": 18,\n",
    "    \"xtick.labelsize\":14, \"ytick.labelsize\":14,\n",
    "})\n",
    "fig, ax = plt.subplots(figsize=(10,6))\n",
    "\n",
    "colors = {\"sqlite\":\"#e52207\", \"mongodb\":\"#e5a000\", \"parquetdb\":\"#59b9de\"}\n",
    "\n",
    "# SQLite\n",
    "ax.plot(df_sql_no[\"n_rows\"], df_sql_no[\"read_noidx\"],\n",
    "        label=\"SQLite w/o index\", color=colors[\"sqlite\"], linestyle=\"dashed\", marker=\"o\", fillstyle=\"none\")\n",
    "ax.plot(df_sql_ix[\"n_rows\"], df_sql_ix[\"read_idx\"],\n",
    "        label=\"SQLite with index\", color=colors[\"sqlite\"], linestyle=\"solid\", marker=\"o\")\n",
    "\n",
    "# MongoDB\n",
    "ax.plot(df_mg_no[\"n_rows\"], df_mg_no[\"read_noidx\"],\n",
    "        label=\"MongoDB w/o index\", color=colors[\"mongodb\"], linestyle=\"dashed\", marker=\"o\", fillstyle=\"none\")\n",
    "ax.plot(df_mg_ix[\"n_rows\"], df_mg_ix[\"read_idx\"],\n",
    "        label=\"MongoDB with index\", color=colors[\"mongodb\"], linestyle=\"solid\", marker=\"o\")\n",
    "\n",
    "# ParquetDB\n",
    "ax.plot(df_pq[\"n_rows\"], df_pq[\"read\"],\n",
    "        label=\"ParquetDB\", color=colors[\"parquetdb\"], linestyle=\"solid\", marker=\"o\")\n",
    "\n",
    "ax.set_xlabel(\"Number of Rows\")\n",
    "ax.set_ylabel(\"Read Time (s)\")\n",
    "ax.set_xscale(\"log\")\n",
    "ax.set_yscale(\"log\")\n",
    "ax.grid(True)\n",
    "\n",
    "# Inset\n",
    "ax_in = inset_axes(ax, width=\"36%\", height=\"36%\", loc=\"upper left\",\n",
    "                   bbox_to_anchor=(0.1,-0.03,1,1), bbox_transform=ax.transAxes)\n",
    "for label, df_ in [(\"SQLite no idx\", df_sql_no), (\"SQLite idx\", df_sql_ix),\n",
    "                   (\"Mongo no idx\", df_mg_no), (\"Mongo idx\", df_mg_ix),\n",
    "                   (\"ParquetDB\", df_pq)]:\n",
    "    ax_in.plot(df_[\"n_rows\"], df_.filter(like=\"read\"), marker=\"o\", label=label)\n",
    "ax_in.set_xscale(\"log\"); ax_in.set_yscale(\"log\")\n",
    "ax_in.set_xlabel(\"Rows (log)\", fontsize=8)\n",
    "ax_in.set_ylabel(\"Time (log)\", fontsize=8)\n",
    "ax_in.grid(True)\n",
    "\n",
    "ax.legend(loc=\"upper center\", bbox_to_anchor=(0.12,0,1,1))\n",
    "ax.set_title(\"Needle‑in‑Haystack Read Benchmark\")\n",
    "plt.tight_layout()\n",
    "\n",
    "plt.savefig(os.path.join(bench_dir,\"needle-in-haystack_benchmark.pdf\"))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Discussion\n",
    "\n",
    "1. **Absolute performance hierarchy**  \n",
    "   - **SQLite with index** is consistently the fastest lookup engine across all scales—about an order of magnitude faster than any other backend.  \n",
    "   - **MongoDB with index** trails SQLite by a small constant factor but remains a solid 2nd place when an index is present.  \n",
    "   - **ParquetDB** (no secondary index) starts off in the middle, beating MongoDB w/o index but behind both indexed engines, but still competitive.\n",
    "\n",
    "2. **Scalability of row‑based vs. columnar**  \n",
    "   - Both **SQLite** and **MongoDB without an index** degrade rapidly as row‑count grows, owing to their full‑table scans.  \n",
    "   - ParquetDB’s read time is flat up to ~100 K rows—then matches a full‑scan profile at 10 K and 100 K, before **diverging back to a faster slope at 1 M**.\n",
    "\n",
    "3. **Why ParquetDB “bounces back” at 1 M rows**  \n",
    "   - ≤ 100 K rows ⇒ only **1 row‑group** in the file ⇒ single‑threaded scan of all pages  \n",
    "   - 1 M rows  ⇒ **10 row‑groups** ⇒ PyArrow’s multithreading + row‑group skipping via metadata statistics kicks in ⇒ turnaround time drops below the single‑scan curve\n",
    "\n",
    "4. **Index‑scan overhead trade‑offs**  \n",
    "   - MongoDB with an index is slightly slower than a full scan for very small tables (≤ 100 rows).  \n",
    "   - At tiny scales the “binary tree walk + random I/O” of an index can actually cost more than a pure sequential scan.\n",
    "\n",
    "5. **Takeaways & tuning knobs**  \n",
    "   - For **point‑look workloads** on small to moderate data sizes, traditional row‑stores with an index remain unbeatable.  \n",
    "   - For **very large datasets**, a columnar engine that can skip entire row‑groups and leverage multithreading can reclaim the lead—even without a secondary index.  \n",
    "   - **Row‑group size** is your key tuning parameter in ParquetDB: smaller groups lower latency for medium‑sized tables, while larger groups boost throughput on huge tables.\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "parquetdb_dev",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.20"
  },
  "nbsphinx": {
   "execute": "never"
  },
  "nbsphinx-thumbnail": {
   "tooltip": "In this example, we benchmark the performance for needle-in-haystack lookup in ParquetDB vs. SQLite and MongoDB."
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
